package com.haoma.service.impl;

import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.haoma.dto.MessageDto;
import com.haoma.entity.Message;
import com.haoma.entity.MessageDb;
import com.haoma.exception.BlogException;
import com.haoma.mapper.MessageMapper;
import com.haoma.minio.MinIOConfig;
import com.haoma.minio.MinIOConfigProperties;
import com.haoma.service.MessageService;
import com.haoma.vo.MessageVo;
import io.minio.BucketExistsArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.PutObjectArgs;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.*;

/**
 * Description:
 */
@Service
public class MessageServiceImpl extends ServiceImpl<MessageMapper, MessageDb> implements MessageService {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private MessageMapper messageMapper;

    /**
     * 查询所有的留言
     *
     * @return
     */
    public List<MessageVo> queryAllMessage() {
        // 查询到所有的留言
        List<Message> messageList = mongoTemplate.find(new Query(), Message.class);
        // 遍历查询所有的留言下的id 获取到名称集合和头像
        // 创建一个去重的集合
        Set<String> idList = new HashSet<>();
        // 遍历
        messageList.forEach(item -> {
            // 存储
            idList.add(item.getMessage_id());
        });
        // 统一查询
        List<MessageDb> messageDbs = messageMapper.selectBatchIds(idList);
        // 存储返回数据
        List<MessageVo> messageVoList = new ArrayList<>();
        // 遍历所有消息
        for (Message message : messageList) {
            // 创建返回对象
            MessageVo messageVo = new MessageVo();
            // 遍历数据库对象
            messageDbs.forEach(item -> {
                // 判断如果mongoDb中的id如果等于数据库的id
                if (message.getMessage_id().equals(item.getId().toString())) {
                    // 存储起来
                    messageVo.setUserUrl(item.getUserUrl());
                    messageVo.setContent(message.getContent());
                    messageVo.setName(item.getName());
                }
            });
            // 存放
            messageVoList.add(messageVo);
        }
        return messageVoList;
    }

    /**
     * 添加留言用户
     *
     * @param messageDb
     */
    public void addMessageUser(MessageDb messageDb) {
        LambdaQueryWrapper<MessageDb> messageDbLambdaQueryWrapper = new LambdaQueryWrapper<>();
        messageDbLambdaQueryWrapper.eq(MessageDb::getName, messageDb.getName());
        MessageDb messageDb1 = messageMapper.selectOne(messageDbLambdaQueryWrapper);
        if (messageDb1 != null) {
            throw new BlogException("重复用户名");
        }
        messageMapper.insert(messageDb);
    }

    @Autowired
    private MinIOConfig minIOConfig;

    @Autowired
    private MinIOConfigProperties minIOConfigProperties;

    /**
     * 头像上传
     *
     * @param multipartFile
     * @return
     */
    public String fileUpload(MultipartFile multipartFile) {
        try {
            // 获取到minio客户端
            MinioClient minioClient = minIOConfig.buildMinioClient();
            // 判断桶是否存在
            boolean isBucket = minioClient.bucketExists(BucketExistsArgs
                    .builder()
                    .bucket(minIOConfigProperties.getBucket())
                    .build());
            // 校验
            if (isBucket) {
                // 存在
                System.out.println("桶存在可以上传了");
            } else {
                // 不存在创建一个
                minioClient.makeBucket(MakeBucketArgs
                        .builder()
                        .bucket(minIOConfigProperties.getBucket())
                        .build());
            }
            // 日期
            String date = DateUtil.format(new Date(), "yyyyMMdd");
            // 唯一的参数
            String uuid = UUID.randomUUID().toString().replace("-", "");
            // 拼接路径
            String filePath = "web-messageuser-avatart" + "/" + date + "/" + uuid + multipartFile.getOriginalFilename();
            // 创建桶的参数
            PutObjectArgs putObjectArgs = PutObjectArgs
                    .builder()
                    .object(filePath)
                    .bucket(minIOConfigProperties.getBucket())
                    .stream(multipartFile.getInputStream(), multipartFile.getSize(), -1)
                    .build();
            // 上传至minio客户端
            minioClient.putObject(putObjectArgs);
            // 将路径返回
            return minIOConfigProperties.getReadPath() + "/" + minIOConfigProperties.getBucket() + "/" + filePath;
        } catch (Exception e) {
            throw new BlogException("上传失败");
        }
    }

    /**
     * 发送留言信息
     *
     * @param messageDto
     */
    public void sendMessage(MessageDto messageDto) {
        // 查询数据库的留言用户信息
        LambdaQueryWrapper<MessageDb> messageLambdaQueryWrapper = new LambdaQueryWrapper<>();
        messageLambdaQueryWrapper.eq(MessageDb::getUserUrl, messageDto.getUserUrl());
        MessageDb messageDb = messageMapper.selectOne(messageLambdaQueryWrapper);
        // 插入到mongoDb中
        Message message = new Message();
        message.setMessage_id(messageDb.getId().toString());
        message.setContent(messageDto.getContent());
        // 创建一个Date对象
        Date date = new Date();
        // 使用Hutool将Date格式化为字符串
        String formattedDateStr = DateUtil.format(date, "yyyy-MM-dd HH:mm:ss");
        message.setCreateTime(formattedDateStr);
        message.setUpdateTime(formattedDateStr);
        mongoTemplate.insert(message, "message");
    }
}
